package com.android.support.lib.universal.util;

import java.util.HashMap;
import java.util.Map;

import com.android.support.lib.universal.listenner.ListennerLc;

import android.content.Context;
import android.media.AudioManager;
import android.media.SoundPool;
import android.media.SoundPool.OnLoadCompleteListener;

/**
 * 适合短暂播放但对反应速度要求较高的音频，SoundPool是异步初始化，初始化后不能立即播放，需要等待片刻，否则出现错误 使用说明：
 * 
 * 初始化：等一会儿 int[] bea = new int[] { R.raw.bea }; pool.load(context, bea,new
 * ListennerLc() {
 * 
 * @Override public void complete() {//声音加载完成 // TODO Auto-generated method stub
 *           if (pool.isComplete) { pool.play(-1, 1);//-1表示循环播放 } } });
 * 
 * 
 *           播放： pool.play(0, 1);
 * 
 * @author 彭治铭
 *
 */
public class UtilSoundPool implements OnLoadCompleteListener {
	/**
	 * 创建了一个最多支持3个流同时播放的，类型标记为音乐的SoundPool。
	 */
	public static SoundPool soundPool = new SoundPool(3,
			AudioManager.STREAM_MUSIC, 0);
	/**
	 * 一般把多个声音放到HashMap中去
	 */
	public static Map<Integer, Integer> map;
	/**
	 * 记录播放ID
	 */
	public static Map<Integer, Integer> mapPlay;
	/**
	 * 资源是否加载完成
	 */
	public static Boolean isComplete = false;
	ListennerLc complete;

	/**
	 * 加载raw文件夹下的声音文件,最多支持3个流同时播放的
	 * 
	 * @param context
	 * @param resId
	 *            声音文件数组,如int[] bea = new int[] { R.raw.bea };
	 * @param complete
	 *            资源加载完成回调方法。
	 */
	public void load(Context context, int[] resId, ListennerLc complete) {
		map = new HashMap<Integer, Integer>();
		for (int i = 0; i < resId.length; i++) {
			int sid = soundPool.load(context, resId[i], 1);// 最后一个参数为优先级。
			map.put(i, sid);
		}
		/**
		 * 实现资源加载结束的监听函数
		 */
		isComplete = false;
		soundPool.setOnLoadCompleteListener(this);
		if(complete!=null){
			this.complete = complete;
		}
	}

	/**
	 * 播放
	 * 
	 * @param loop
	 *            循环次数(从0开始)，0播放一次,1播放两次
	 * @param rate
	 *            速率最低0.5最高为2，1代表正常速度
	 */
	public void play(int loop, int rate) {
		if (isComplete) {
			stop();// 播放之前，先停止正在播放的。
			mapPlay = new HashMap<Integer, Integer>();
			for (int i = 0; i < map.size(); i++) {
				int s = soundPool.play(map.get(i), 1, 1, 0, loop, rate);
				mapPlay.put(i, s);
			}
		}
	}

	/**
	 * 暂停播放
	 */
	public void pause() {
		if (isComplete) {
			if (mapPlay != null && mapPlay.size() > 0) {
				for (int i = 0; i < mapPlay.size(); i++) {
					soundPool.pause(mapPlay.get(i));
				}
			}
		}
	}

	/**
	 * 恢复播放
	 */
	public void resume() {
		if (isComplete) {
			if (mapPlay != null && mapPlay.size() > 0) {
				for (int i = 0; i < mapPlay.size(); i++) {
					soundPool.resume(mapPlay.get(i));
				}
			}
		}
	}

	/**
	 * 停止播放
	 */
	public void stop() {
		if (isComplete) {
			if (mapPlay != null && mapPlay.size() > 0) {
				for (int i = 0; i < mapPlay.size(); i++) {
					soundPool.stop(mapPlay.get(i));
				}
			}
		}
	}

	/**
	 * 实现资源加载结束的监听函数
	 */
	@Override
	public void onLoadComplete(SoundPool soundPool, int sampleId, int status) {
		// TODO Auto-generated method stub
		isComplete = true;
		// 回调资源加载完成
		if(complete!=null){
			complete.complete();
		}
	}
}
